package com.echo.im.client;

import com.echo.im.client.model.IMTerminalType;
import com.echo.im.client.router.MessageRouter;
import com.echo.im.client.status.UserStatusService;
import com.echo.im.client.util.GenericTypeUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * 对外提供统一抽象
 * @author lxy
 * @date 2024-08-14
 */
@Slf4j
@Component
public class IMClient {

    private final UserStatusService userStatusService;
    private final Map<Class<?>, MessageRouter> messageHandlerMap;

    @Autowired(required = false)
    public IMClient(UserStatusService userStatusService, List<MessageRouter<?>> messageRouterList) {
        this.userStatusService = userStatusService;
        this.messageHandlerMap = new HashMap<>();

        // 初始化消息处理器映射
        if (messageRouterList != null) {
            for (MessageRouter<?> messageRouter : messageRouterList) {
                try {
                    Class<?> messageType = GenericTypeUtil.getFirstGenericTypeOfInterface(
                            messageRouter.getClass(),
                            MessageRouter.class
                    );
                    messageHandlerMap.put(messageType, messageRouter);
                } catch (NoClassDefFoundError e) {
                    log.error("无法加载 MessageRouter 类: " + e.getMessage());
                }
            }
        }
    }

    /**
     * 发送消息方法
     * @param message 要发送的消息
     * @param <T> 消息类型
     */
    public <T> void sendMessage(T message) {
        if (messageHandlerMap == null) {
            log.error("消息路由器映射未初始化！");
            return;
        }

        MessageRouter messageRouter = messageHandlerMap.get(message.getClass());
        if (messageRouter != null) {
            try {
                messageRouter.routeMessage(message);
            } catch (Exception e) {
                log.error("消息路由失败: ", e);
            }
        } else {
            log.error("未找到对应的消息路由器，消息类型为：{}", message.getClass());
        }
    }

    /**
     * 判断用户是否在线
     * @param userId 用户ID
     * @return 在线状态
     */
    public Boolean isUserOnline(Long userId) {
        if (userStatusService == null) {
            log.warn("UserStatusService 未注入，无法检查用户在线状态。");
            return false;  // 或者抛出异常，取决于你的业务逻辑
        }

        try {
            return userStatusService.isUserOnline(userId);
        } catch (Exception e) {
            log.error("检查用户在线状态失败: ", e);
            return false; // 或者抛出自定义异常
        }
    }

    /**
     * 获取在线用户列表
     * @param userIds 用户ID列表
     * @return 在线的用户列表
     */
    public List<Long> getOnlineUser(List<Long> userIds) {
        if (userStatusService == null) {
            log.warn("UserStatusService 未注入，无法获取在线用户列表。");
            return null;  // 或者返回一个空列表，取决于你的业务逻辑
        }

        try {
            return userStatusService.getOnlineUserIdList(userIds);
        } catch (Exception e) {
            log.error("获取在线用户列表失败: ", e);
            return null; // 或者返回一个空列表
        }
    }

    /**
     * 获取在线终端信息
     * @param userIds 用户ID列表
     * @return 在线的用户终端信息
     */
    public Map<Long, List<IMTerminalType>> getOnlineTerminal(List<Long> userIds) {
        if (userStatusService == null) {
            log.warn("UserStatusService 未注入，无法获取在线终端信息。");
            return null;  // 或者返回一个空映射，取决于你的业务逻辑
        }

        try {
            return userStatusService.getUserIdTerminalListMap(userIds);
        } catch (Exception e) {
            log.error("获取在线终端信息失败: ", e);
            return null; // 或者返回一个空映射
        }
    }
}
